#ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once
#endif

#include "yaml-cpp/dll.h"
#include "yaml-cpp/node/ptr.h"
#include <boost/iterator/iterator_facade.hpp>
#include <boost/utility/enable_if.hpp>
#include <map>
#include <utility>
#include <vector>

namespace YAML
{
	namespace detail
	{
		struct iterator_type { enum value { None, Sequence, Map }; };

		template<typename V>
		struct node_iterator_value : public std::pair<V*, V*> {
			typedef std::pair<V*, V*> kv;

			node_iterator_value() : kv(), pNode(0) {}
			explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {}
			explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(0) {}

			V& operator *() const { return *pNode; }
			V& operator ->() const { return *pNode; }

			V *pNode;
		};

		typedef std::vector<node *> node_seq;
		typedef std::map<node *, node *> node_map;

		template<typename V>
		struct node_iterator_type {
			typedef node_seq::iterator seq;
			typedef node_map::iterator map;
		};

		template<typename V>
		struct node_iterator_type<const V> {
			typedef node_seq::const_iterator seq;
			typedef node_map::const_iterator map;
		};

		template<typename V>
		class node_iterator_base : public boost::iterator_facade<
			node_iterator_base<V>,
			node_iterator_value<V>,
			std::forward_iterator_tag,
			node_iterator_value<V> >
		{
		private:
			struct enabler {};

		public:
			typedef typename node_iterator_type<V>::seq SeqIter;
			typedef typename node_iterator_type<V>::map MapIter;
			typedef node_iterator_value<V> value_type;

			node_iterator_base() : m_type(iterator_type::None) {}
			explicit node_iterator_base(SeqIter seqIt) : m_type(iterator_type::Sequence), m_seqIt(seqIt) {}
			explicit node_iterator_base(MapIter mapIt, MapIter mapEnd) : m_type(iterator_type::Map), m_mapIt(mapIt), m_mapEnd(mapEnd) {
				m_mapIt = increment_until_defined(m_mapIt);
			}

			template<typename W>
			node_iterator_base(const node_iterator_base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler())
				: m_type(rhs.m_type), m_seqIt(rhs.m_seqIt), m_mapIt(rhs.m_mapIt), m_mapEnd(rhs.m_mapEnd) {}

		private:
			friend class boost::iterator_core_access;
			template<typename> friend class node_iterator_base;

			template<typename W>
			bool equal(const node_iterator_base<W>& rhs) const {
				if (m_type != rhs.m_type)
					return false;

				switch (m_type) {
				case iterator_type::None: return true;
				case iterator_type::Sequence: return m_seqIt == rhs.m_seqIt;
				case iterator_type::Map: return m_mapIt == rhs.m_mapIt;
				}
				return true;
			}

			void increment() {
				switch (m_type) {
				case iterator_type::None: break;
				case iterator_type::Sequence:
					++m_seqIt;
					break;
				case iterator_type::Map:
					++m_mapIt;
					m_mapIt = increment_until_defined(m_mapIt);
					break;
				}
			}

			value_type dereference() const {
				switch (m_type) {
				case iterator_type::None: return value_type();
				case iterator_type::Sequence: return value_type(**m_seqIt);
				case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second);
				}
				return value_type();
			}

			MapIter increment_until_defined(MapIter it) {
				while (it != m_mapEnd && !is_defined(it))
					++it;
				return it;
			}

			bool is_defined(MapIter it) const {
				return it->first->is_defined() && it->second->is_defined();
			}

		private:
			typename iterator_type::value m_type;

			SeqIter m_seqIt;
			MapIter m_mapIt, m_mapEnd;
		};

		typedef node_iterator_base<node> node_iterator;
		typedef node_iterator_base<const node> const_node_iterator;
	}
}

#endif // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
